// Extension Sync - 插件状态同步工具
// 这个文件可以在任何需要同步插件状态的页面中引入

console.log('🔌 Extension Sync 工具已加载');

// 改进的Token管理工具
const TokenManager = {
    // 设置token（带用户信息和过期时间）
    setToken(token, user = {}, expireHours = 24) {
        const authData = {
            token: token,
            user: user,
            expiry: Date.now() + (expireHours * 60 * 60 * 1000),
            timestamp: Date.now()
        };
        
        // 存储到sessionStorage（会话级别）
        sessionStorage.setItem('auth_token', token);
        sessionStorage.setItem('auth_user', JSON.stringify(user));
        
        // 存储到localStorage（持久化，带过期验证）
        localStorage.setItem('auth_data', JSON.stringify(authData));
        
        // 专门为插件存储的数据（固定key名称）
        localStorage.setItem('influ_watch_dog_auth', JSON.stringify({
            ...authData,
            domain: window.location.hostname,
            url: window.location.href
        }));
    },
    
    // 获取token（验证过期时间）
    getToken() {
        // 首先尝试从sessionStorage获取
        let token = sessionStorage.getItem('auth_token');
        if (token) return token;
        
        // 从localStorage获取并验证过期时间
        const authData = localStorage.getItem('auth_data');
        if (authData) {
            try {
                const data = JSON.parse(authData);
                if (data.expiry && Date.now() < data.expiry) {
                    return data.token;
                } else {
                    // token已过期，清除
                    this.clearToken();
                }
            } catch (e) {
                console.error('Token解析失败:', e);
                this.clearToken();
            }
        }
        return null;
    },
    
    // 获取用户信息
    getUser() {
        // 从sessionStorage获取
        const sessionUser = sessionStorage.getItem('auth_user');
        if (sessionUser) {
            try {
                return JSON.parse(sessionUser);
            } catch (e) {
                console.error('用户信息解析失败:', e);
            }
        }
        
        // 从localStorage获取
        const authData = localStorage.getItem('auth_data');
        if (authData) {
            try {
                const data = JSON.parse(authData);
                if (data.expiry && Date.now() < data.expiry) {
                    return data.user || {};
                }
            } catch (e) {
                console.error('用户信息解析失败:', e);
            }
        }
        return null;
    },
    
    // 清除token
    clearToken() {
        sessionStorage.removeItem('auth_token');
        sessionStorage.removeItem('auth_user');
        localStorage.removeItem('auth_data');
        localStorage.removeItem('token'); // 清除旧的token存储
        localStorage.removeItem('influ_watch_dog_auth'); // 清除插件用的数据
        
        // 通知插件登出
        ExtensionSync.notifyLogout();
    },
    
    // 检查token是否有效
    isTokenValid() {
        return !!this.getToken();
    }
};

// Chrome插件同步工具
const ExtensionSync = {
    // 通知插件登录成功
    notifyLogin(data) {
        // 存储插件专用的认证数据
        const extensionAuthData = {
            status: 'authenticated',
            token: data.token,
            user: data.user,
            timestamp: data.timestamp,
            expiry: Date.now() + (24 * 60 * 60 * 1000), // 24小时过期
            domain: window.location.hostname,
            loginUrl: window.location.href
        };
        
        localStorage.setItem('influ_watch_dog_auth', JSON.stringify(extensionAuthData));
        
        // 触发自定义事件，通知Content Script
        this.dispatchAuthEvent('influ_watch_dog_login', extensionAuthData);
        
        console.log('✅ 登录状态已同步到插件，数据:', extensionAuthData);
    },
    
    // 通知插件登出
    notifyLogout() {
        const extensionAuthData = {
            status: 'unauthenticated',
            timestamp: Date.now(),
            domain: window.location.hostname
        };
        
        localStorage.setItem('influ_watch_dog_auth', JSON.stringify(extensionAuthData));
        this.dispatchAuthEvent('influ_watch_dog_logout', extensionAuthData);
        
        console.log('✅ 登出状态已同步到插件');
    },
    
    // 触发自定义事件
    dispatchAuthEvent(type, data) {
        try {
            window.dispatchEvent(new CustomEvent(type, {
                detail: {
                    type: type,
                    data: data,
                    timestamp: Date.now()
                }
            }));
        } catch (e) {
            console.error('触发认证事件失败:', e);
        }
    },
    
    // 获取当前认证状态（供插件查询）
    getCurrentAuthState() {
        const authData = localStorage.getItem('influ_watch_dog_auth');
        if (authData) {
            try {
                const data = JSON.parse(authData);
                // 检查是否过期
                if (data.expiry && Date.now() < data.expiry) {
                    return data;
                } else {
                    // 已过期，清除
                    localStorage.removeItem('influ_watch_dog_auth');
                }
            } catch (e) {
                console.error('认证状态解析失败:', e);
            }
        }
        return null;
    },

    // 检查并同步认证状态（解决状态不一致问题）
    async checkAndSyncAuthState() {
        console.log('🔍 开始检查认证状态同步...');

        // 1. 检查localStorage中的状态
        const localAuthData = this.getCurrentAuthState();
        
        // 2. 检查Web端是否真的已登录
        const webAuthStatus = await this.checkWebAuthStatus();
        
        console.log('📊 状态对比:', {
            localStorage: localAuthData ? '有效' : '无效/过期',
            webAuth: webAuthStatus.isAuthenticated ? '已登录' : '未登录'
        });

        // 3. 根据状态进行同步
        if (webAuthStatus.isAuthenticated && !localAuthData) {
            // Web端已登录，但localStorage无效 -> 重新获取token并同步
            console.log('🔄 检测到状态不一致：Web端已登录但插件状态无效，正在重新同步...');
            await this.refreshAuthState(webAuthStatus);
            
        } else if (!webAuthStatus.isAuthenticated && localAuthData) {
            // Web端未登录，但localStorage有效 -> 清除插件状态
            console.log('🔄 检测到状态不一致：Web端未登录但插件状态有效，正在清除...');
            this.notifyLogout();
            
        } else if (webAuthStatus.isAuthenticated && localAuthData) {
            // 双方都有效，检查token是否需要刷新
            await this.checkTokenRefresh(localAuthData, webAuthStatus);
            console.log('✅ 认证状态同步正常');
            
        } else {
            // 双方都无效
            console.log('ℹ️ Web端和插件都未登录，状态一致');
        }
    },

    // 检查Web端认证状态
    async checkWebAuthStatus() {
        try {
            const response = await fetch('/api/auth-status', {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content')
                },
                credentials: 'include' // 包含cookies
            });

            if (response.ok) {
                const data = await response.json();
                return {
                    isAuthenticated: data.authenticated || false,
                    user: data.user || null,
                    needsTokenRefresh: data.needsTokenRefresh || false
                };
            }
        } catch (error) {
            console.error('❌ 检查Web认证状态失败:', error);
        }

        return { isAuthenticated: false, user: null };
    },

    // 刷新认证状态
    async refreshAuthState(webAuthStatus) {
        try {
            // 请求新的API token
            const response = await fetch('/api-token', {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content')
                },
                credentials: 'include'
            });

            if (response.ok) {
                const data = await response.json();
                if (data.success && data.api_token) {
                    // 使用新token同步状态
                    this.notifyLogin({
                        token: data.api_token,
                        user: data.user || webAuthStatus.user,
                        timestamp: Date.now()
                    });
                    
                    console.log('✅ 认证状态已自动刷新并同步');
                    return true;
                }
            }
        } catch (error) {
            console.error('❌ 刷新认证状态失败:', error);
        }
        
        return false;
    },

    // 检查token是否需要刷新
    async checkTokenRefresh(localAuthData, webAuthStatus) {
        const now = Date.now();
        const tokenAge = now - (localAuthData.timestamp || 0);
        const maxAge = 7 * 24 * 60 * 60 * 1000; // 7天

        // 如果token超过7天，主动刷新
        if (tokenAge > maxAge || webAuthStatus.needsTokenRefresh) {
            console.log('🔄 Token较旧，主动刷新...');
            await this.refreshAuthState(webAuthStatus);
        }
    },

    // 初始化同步机制
    init() {
        // 页面加载时检查状态
        this.checkAndSyncAuthState();
        
        console.log('✅ Extension Sync 初始化完成');
    }
};

// 自动初始化（当页面加载完成时）
document.addEventListener('DOMContentLoaded', function() {
    ExtensionSync.init();
});

// 暴露到全局，方便调试和其他脚本使用
window.ExtensionSync = ExtensionSync;
window.TokenManager = TokenManager; 